package com.ceres.device.service.impl;


import com.ceres.device.dao.DeviceMapper;
import com.ceres.device.dao.Device_indexMapper;

import com.ceres.device.dao.InfoMapper;
import com.ceres.device.entity.QueryPageBean;
import com.ceres.device.pojo.Device;
import com.ceres.device.pojo.Device_Index;
import com.ceres.device.pojo.Info;
import com.ceres.device.service.DeviceService;;;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 *  业务代码
 */
@Service
public class DeviceServiceImpl implements DeviceService {
    /**
     *  依赖注入
     */
    @Autowired
    DeviceMapper deviceMapper;
    /**
     *  依赖注入
     */
    @Autowired
    InfoMapper infoMapper;
    /**
     *  依赖注入
     */
    @Autowired
    Device_indexMapper device_indexMapper;

    /**
     * 智能设备的新增
     */
    @Transactional
    public void deviceAdd(Device device) {
        Info info = device.getInfoEntity();
        Device_Index device_indexEntity = device.getDevice_indexEntity();
        //先判断新加设备是否为空
        //新增设备信息
        if (device != null) {
            //获取设备信息的实体
            //获取设备信息的id
            device.setInfoId(info.getDid());
            //设置智能设备的指标id
            device.setDevice_indexId(device_indexEntity.getIid());
            /**
             *   智能设备基本信息的新增功能
             */
            int add = deviceMapper.deviceAdd(device);
            if (add == 0) {
                throw new RuntimeException("添加失败");
            }
            /**
             *    智能设备的说明书的新增功能
             */
            int infoAdd = infoMapper.infoAdd(info);
            if (infoAdd == 0) {
                throw new RuntimeException("设备信息添加失败");
            }
            /**
             *     智能设备的指标的新增功能
             */
            int i = device_indexMapper.add(device_indexEntity);
            if (i == 0) {
                throw new RuntimeException("设备指标添加失败");
            }
        }
    }

    /**
     * 查询所有的智能设备
     */
    @Transactional
    public List<Device> findAll3() {
        List<Device> list = new ArrayList();
        //返回的智能设备集合
        List<Device> deviceList = deviceMapper.select2All();
        if (deviceList != null) {
            for (Device device : deviceList) {
                if (device.getState() != null && device.getState() != "0" && device.getState() != "") {
                    /**
                     *  获取智能设备的说明书
                     */
                    List<Info> infoList = infoMapper.select2Info(device.getInfoId());
                    if (deviceList != null) {
                        for (Info info : infoList) {
                            //设备说明表封装到一个实体类中
                            device.setInfoEntity(info);
                            list.add(device);
                        }
                        List<Device_Index> indexList = device_indexMapper.select2Index(device.getDevice_indexId());
                        for (Device_Index deviceIndex : indexList) {
                            /**
                             *   获取智能设备的指标
                             */
                            device.setDevice_indexEntity(deviceIndex);
                            list.add(device);
                        }
                    }
                }
            }

        }
        return list;
    }

    /**
     * 修改智能设备信息
     */
    @Transactional
    public void deviceUpdate(Device device) {
        //1. 先判断智能设备是否为空
        if (device != null) {
            Integer id = device.getId();
            /**
             *      根据设备的Id返回设备的状态码
             */
            int stateId = deviceMapper.select2State(id);
            if (stateId == 0) {
                /**
                 *      设备状态=0 代表设备已经被删除 无法修改
                 */
                throw new RuntimeException("智能设备已经被下架或者被删除，请联系超级管理员咨询");
            } else {
                /**
                 *   修改智能设备的基本信息
                 */
                int dm = deviceMapper.updateByPrimaryKeySelective(device);
                if (dm == 0) {
                    throw new RuntimeException("智能设备修改失败，请联系超级管理员咨询");
                }
                /**
                 *   修改智能设备的说明书
                 */
                int info = infoMapper.updateByInfo(device.getInfoEntity());
                if (info == 0) {
                    throw new RuntimeException("智能设备说明书修改失败，请联系超级管理员咨询");
                }
                /**
                 *   修改智能设备的指标
                 */
                int index = device_indexMapper.updateByIndexDevice(device.getDevice_indexEntity());
                if (index == 0) {
                    throw new RuntimeException("智能设备指标修改失败，请联系超级管理员咨询");
                }
            }
        }
    }

    /**
     * 删除根据设备的Id 正常状态改成0
     *
     * @param device
     */
    @Transactional
    public void deviceDelete(Device device) {
        /**
         *   判断设备是否为空
         */
        if (device != null) {
            /**
             * 通过实体的id 查询对应的实体对象是否存在
             */
            Integer id = device.getId();
            //查询这智能设备状态
            String state = String.valueOf(deviceMapper.select2State(id));
            if (state == "0") {
                throw new RuntimeException("智能设备已经被删除，请联系超级管理员咨询");
            }
            device.setState("0");
            //修改智能设备状态
            int i = deviceMapper.updateByState(device);
            if (i == 0) {
                throw new RuntimeException("智能设备删除失败，请联系超级管理员咨询");
            }
        }
    }

    /**
     * 根据id查询单个智能设备的功能
     *
     * @param id
     * @return
     */
    @Transactional
    public Device findById(Integer id) {
        List<Device> list = new ArrayList<>();
        Device device = deviceMapper.select4All(id);

        if (device != null) {
            String state = device.getState();
            if (state != null && state != "0") {
                list.add(device);
                //添加智能设备说明书的信息
                Info info = infoMapper.selectInfoOne(device.getInfoId());
                if (info != null) {
                    device.setInfoEntity(info);
                    list.add(device);
                } else {
                    throw new RuntimeException("亲爱的用户你的智能商品说明书可能是空的，请与超级管理联系");
                }
                //添加智能设备指标的信息
                Device_Index deviceIndex = device_indexMapper.select2Index1(device.getDevice_indexId());
                if (deviceIndex != null) {
                    device.setDevice_indexEntity(deviceIndex);
                    list.add(device);
                } else {
                    throw new RuntimeException("亲爱的用户你的智能商品指标可能是空的，请与超级管理联系");
                }

            } else {
                throw new RuntimeException("亲爱的用户你的智能商品可能被下架或者删除，请与超级管理联系");
            }
        }
        return device;
    }


    /**
     * 查询所有，分页查询
     *
     * else {
     *
     *         }
     */
    public Page<Device> findPage(int size ,int page) {
        //分页查询
        PageHelper.startPage(page,size);
        //智能设备
        Page<Device> devicePage = (Page<Device>) deviceMapper.select5all();
        return devicePage;
        }

    /**
     *  分页查询 + 条件查询
     * @param queryPageBean
     * @return
     */
    public Page<Device> findPageQuery(QueryPageBean queryPageBean) {
        //智能设备的当前页
        Integer currentPage = queryPageBean.getCurrentPage();
        //显示几条设备
        Integer pageSize = queryPageBean.getPageSize();
        //查询智能设备的条件
        String queryString = queryPageBean.getQueryString();
        //分页查询
        PageHelper.startPage(currentPage,pageSize);
        //智能设备
        Page<Device> devicePage = (Page<Device>) deviceMapper.select6all(queryString);
        return devicePage;
    }
}

